home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 4 / Amiga Tools 4.iso / tools / internet-tools / amipop118 / source / pop_dopop.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-02-26  |  11.1 KB  |  622 lines
  1. #include "pop.h"
  2.  
  3.  
  4. /* Stuff for "From " Header */
  5. /* Courtesy Michael B. Smith */
  6.  
  7.  
  8. struct mytm    {
  9.                 int year;
  10.                 int month;
  11.                 int day;
  12.                 int dow;
  13.                 int hour;
  14.                 int min;
  15.                 int sec;
  16.             };
  17.  
  18. /* DaysInMonth */
  19. static const int    dim [] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
  20. static const char    *months [] = {    "Jan", "Feb", "Mar", "Apr", "May", "Jun",
  21.                                        "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
  22. static const char    *days [] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
  23.  
  24. static void DateStampToMyTm (struct DateStamp *date, struct mytm *da)
  25. {
  26.     int days, years, leap  = 0, month = 0;
  27.  
  28.     days = date->ds_Days + 731;        /*  1976    */
  29.     years = days / (365*3+366);        /*  #quad yrs    */
  30.     days -= years * (365*3+366);
  31.     years = 1976 + 4 * years;
  32.  
  33.     if (days <= 365)
  34.     {
  35.         leap = 1;
  36.     }
  37.     else
  38.     {
  39.         days -= 366;
  40.         ++years;
  41.         years += days / 365;
  42.         days %= 365;
  43.     }
  44.  
  45.     month = 0;
  46.     while (1)
  47.     {
  48.         if (month == 1)
  49.         {
  50.             if (days < (28 + leap)) break;
  51.             days -= 28 + leap;
  52.         }
  53.         else
  54.         {
  55.             if (days < dim [month]) break;
  56.             days -= dim [month];
  57.         }
  58.         ++month;
  59.     }
  60.  
  61.     da->hour   = date->ds_Minute / 60;
  62.     da->min    = date->ds_Minute % 60;
  63.     da->sec    = date->ds_Tick / 50;
  64.  
  65.     da->day    = days + 1;
  66.     da->month  = month + 1;
  67.     da->dow    = date->ds_Days % 7;    /*  0 = sunday   */
  68.     da->year   = years;
  69.  
  70.     return;
  71. }
  72.  
  73. char * datestr (char *buf)
  74. {
  75.     /*
  76.     **  datestr
  77.     **
  78.     **    Build ARPA date-time as specified in RFC-822:
  79.     **
  80.     **        Wed, 13 Oct 93 18:52:04 EST
  81.     **        123456789012345678901234567890
  82.     **
  83.     **    buf must be 24 characters, plus space for TimeZone and NUL.
  84.     **
  85.     **    As TimeZone may be "(+23:30)" or similar, 33 chars should
  86.     **    do it.
  87.     */
  88.     struct mytm da;
  89.     struct DateStamp ds;
  90.  
  91.     DateStampToMyTm (DateStamp (&ds), &da);
  92.  
  93.     DoFmt (buf, "%s, %ld %s %ld %02ld:%02ld:%02ld",
  94.                 days [da.dow], da.day,
  95.                 months [da.month - 1], da.year % 100,
  96.                 da.hour, da.min, da.sec);
  97.  
  98.     return buf;
  99. }
  100.  
  101. char * time_stamp (char *buf)
  102. {
  103.     /*
  104.     **  time_stamp
  105.     **
  106.     **    Put a time/date stamp into buf (for logging)
  107.     **
  108.     **    13 Nov 93 13:14:45
  109.     */
  110.     struct DateStamp ds;
  111.     struct mytm da;
  112.  
  113.     DateStampToMyTm (DateStamp (&ds), &da);
  114.  
  115.     DoFmt (buf, "%ld %s %ld %02ld:%02ld:%02ld",
  116.                 da.day,
  117.                 months [da.month - 1], da.year % 100,
  118.                 da.hour, da.min, da.sec);
  119.  
  120.     return buf;
  121. }
  122.  
  123. /*  End stuff for "From " header */
  124.  
  125.  
  126. #define ASYNCBUFSIZE 8192
  127.  
  128. BOOL needfrom ( char * , struct AsyncFile *);
  129.  
  130. /* Variables global to this file */
  131.  
  132. struct Library *SockBase ;
  133. int havemail;
  134.  
  135. /* Functions */
  136.  
  137. int dopop(void)
  138. {
  139.     int s;
  140.     int count=1;
  141.     int okay=1;
  142.     struct hostent *hp;
  143.     struct sockaddr_in sa;
  144.  
  145.     /*DoFmt(title,"Connecting to %s",pophost);
  146.     settitle(title);*/
  147.  
  148.     if((SockBase = OpenLibrary( SOCKLIBNAME, SOCKLIBVERSION )) == NULL)
  149.     {
  150.         doreq("Error opening "SOCKLIBNAME"\n",bum);
  151.         return(1);
  152.     }
  153. #ifdef AMITCP
  154.     SetErrnoPtr(&errno, sizeof errno);
  155. #else
  156.     setup_sockets( MAXSOCKS, &errno );
  157. #endif
  158.  
  159.     if((hp=gethostbyname(pophost))==NULL)
  160.     {
  161. #ifndef AMITCP
  162.         cleanup_sockets();
  163. #endif
  164.         CloseLibrary( SockBase ) ;
  165.         doreq("Connection Refused.",bum);
  166.         return(1);
  167.     }
  168.  
  169.     bzero(&sa, sizeof(sa));
  170.     bcopy(hp->h_addr, (char *)&sa.sin_addr, hp->h_length);
  171.     sa.sin_family = hp->h_addrtype;
  172.     sa.sin_port = htons((u_short)port);
  173.     if ((s=socket(hp->h_addrtype,SOCK_STREAM,0)) < 0)
  174.     {
  175. #ifndef AMITCP
  176.         cleanup_sockets();
  177. #endif
  178.         CloseLibrary( SockBase ) ;
  179.         doreq("Something bad\nhas happened.",bum);
  180.         return(1);
  181.     }
  182.  
  183.     if (connect(s,(struct sockaddr *) &sa,sizeof(sa))< 0)
  184.     {
  185.         doreq("No POP3 daemon\nrunning on this\nmachine or port.",bum);
  186.         s_close(s);
  187. #ifndef AMITCP
  188.         cleanup_sockets();
  189. #endif
  190.         CloseLibrary( SockBase ) ;
  191.         return(1);
  192.     }
  193.  
  194. /* Put actual code here */
  195.  
  196. /* We need to loop on this recv, because the initial greeting may not fit in one BUFSIZE.
  197.    We loop until we get a "\n" */
  198.  
  199.     settitle("Got Connection");
  200.  
  201.     recv(s,buf,BUFSIZE-1,0);
  202.     while (!(strstr(buf,"\n")))
  203.     {
  204.         recv(s,buf,BUFSIZE-1,0);
  205.     }
  206.  
  207.  
  208.     if (senduser(s))
  209.     {
  210. #ifndef AMITCP
  211.         cleanup_sockets();
  212. #endif
  213.         CloseLibrary( SockBase ) ;
  214.         return(1);
  215.     }
  216.  
  217.     havemail=sendstat(s);
  218.  
  219.     while ((okay) && ((havemail > count) || (havemail == count)))
  220.     {
  221.         DoFmt(title,"Retrieving %lu of %lu",count,havemail);
  222.         settitle(title);
  223.  
  224.         okay=retrieve(s,count);
  225.  
  226.         if (delmail && okay)
  227.         {
  228.             DoFmt(title,"Deleting %lu",count);
  229.             settitle(title);
  230.  
  231.             okay=delmessage(s,count);
  232.         }
  233.         ++count;
  234.     }
  235.  
  236.     if(sendquit(s))
  237.     {
  238. #ifndef AMITCP
  239.         cleanup_sockets();
  240. #endif
  241.         CloseLibrary( SockBase ) ;
  242.         return(1);
  243.     }
  244.  
  245.     /*if (Project0Wnd)
  246.     {
  247.         SetWindowTitles(Project0Wnd,Project0Wdt, (UBYTE *) ~0);
  248.     }*/
  249.  
  250.     if (havemail && notify) /* removed sendstat() after Nofify */
  251.     {
  252.         doreq("You have new mail.","Cool");
  253.     }
  254.  
  255. /* End actual code */
  256.  
  257.     s_close(s);
  258. #ifndef AMITCP
  259.     cleanup_sockets();
  260. #endif
  261.     CloseLibrary( SockBase ) ;
  262.     return(0);
  263. }
  264.  
  265. int senduser(int s)
  266. {
  267.     int t;
  268.  
  269.     settitle("Sending Username");
  270.  
  271.     DoFmt(buf,"USER %s\r\n",username);
  272.  
  273.     if ( !trans(s,buf) ) return(1);
  274.  
  275.     t=sscanf(buf,"%s",temp);
  276.     if ( valcheck(t,temp) ) return(1);
  277.  
  278. /* Password */
  279.  
  280.     if (password[1])
  281.     {
  282.         settitle("Sending Password");
  283.  
  284.         DoFmt(buf,"PASS %s\r\n",password);
  285.  
  286.         if ( !trans(s,buf) ) return(1);
  287.  
  288.         t=sscanf(buf,"%s",temp);
  289.  
  290.         if ( valcheck(t,temp) ) return(1);
  291.     }
  292.  
  293.     return(0);
  294. }
  295.  
  296. int sendquit(int s)
  297. {
  298.     int t;
  299.  
  300.     settitle("Sending QUIT");
  301.  
  302.     DoFmt(buf,"QUIT\r\n");
  303.  
  304.     if ( !trans(s,buf) ) return(1);
  305.  
  306.     t=sscanf(buf,"%s",temp);
  307.  
  308.     if ( valcheck(t,temp) ) return(1);
  309.  
  310.     settitle("Quit Acknowledged");
  311.  
  312.     return(0);
  313. }
  314.  
  315. int sendstat( int s )
  316. {
  317.     int t;
  318.     int count=0;
  319.  
  320.     DoFmt(buf,"STAT\r\n");
  321.  
  322.     if ( !trans(s,buf) ) return(0);
  323.  
  324.     t=sscanf(buf,"%s %lu",temp,&count);
  325.  
  326.     if ( valcheck(t,temp) ) return(0);
  327.  
  328.     return(count);
  329. }
  330.  
  331. /* function retrieve does the work of retrieving a message, removing
  332.    the byte stuffing and writing it to the mailfile.
  333.    Rewritten by David Duggan, Sandia National Labs */
  334.  
  335. int retrieve(int s, int count)
  336. {
  337.     int foo;            /* temp integer for numb bytes read */
  338.     int state;            /* flag saying what state we are in */
  339.     int x1;            /* index for tmpbuf */
  340.  
  341.     char *tmpbuf;        /* ptr to place to put unstuffed msg */
  342.     char *buf3;            /* ptr to front of mail message */
  343.     char *buf4;            /* ptr to char being examined in mail message */
  344.  
  345.     struct AsyncFile *ofp;
  346.  
  347.     if ( ! (tmpbuf = AllocVec(BUFSIZE,MEMF_CLEAR)))
  348.     {
  349.         doreq("Not enough memory for buffer.",bum);
  350.         return(0);
  351.     }
  352.  
  353.     if (( count == 1 ) && ( !appfile ))
  354.     {
  355.         ofp = OpenAsync(mailbox, MODE_WRITE,ASYNCBUFSIZE);
  356.     }
  357.     else
  358.     {
  359.         ofp = OpenAsync(mailbox, MODE_APPEND,ASYNCBUFSIZE);
  360.     }
  361.  
  362.     if ( ofp == NULL )
  363.     {
  364.         doreq("Unable to lock Mailbox.\nCheck path and filename.",bum);
  365.         FreeVec(tmpbuf);
  366.         return(0);
  367.     }
  368.  
  369.     DoFmt(buf,"RETR %lu\r\n",count);
  370.  
  371.     if ( !trans(s,buf) )    /* send data, get answer */
  372.     {
  373.         CloseAsync(ofp);
  374.         FreeVec(tmpbuf);
  375.         return(0);
  376.     }
  377.  
  378.     if ( valcheck(1,buf) )    /* check for good response */
  379.     {
  380.         CloseAsync(ofp);
  381.         FreeVec(tmpbuf);
  382.         return(0);
  383.     }
  384.  
  385.     /* Here we have a good first line for this multi-line response.
  386.        Now we should process the rest of the buffer */
  387.  
  388.     buf3 = strstr(buf,"\r\n");
  389.     if (buf3 != NULL) buf3 += 2;/* move ptr past first line */
  390.     needfrom(buf3,ofp);    /* add "from" if needed */
  391.     buf4 = buf3 = strip(buf3); /* remove CRs */
  392.  
  393.     state = 0;        /* start clean every time */
  394.     while ( state < 3 )
  395.     {
  396.         x1 = 0;            /* reset index */
  397.         while ( *buf4 )        /* until we hit the end of buffer */
  398.         {
  399.             switch (state)
  400.             {
  401.                 case 0:
  402.                     if ( *buf4 == '\n' )
  403.                     {
  404.                         state++;    /* go to next state */
  405.                     }
  406.                     tmpbuf[x1++] = *buf4;/* move character */
  407.                     break;
  408.  
  409.                 case 1:
  410.                     if ( *buf4 == '.' )
  411.                     {
  412.                         state++;    /* next state, deleting period */
  413.                     }
  414.                     else
  415.                     {    /* reset state if not "\n"  */
  416.                         if (*buf4 != '\n')
  417.                         {
  418.                             state = 0;
  419.                         }
  420.                         tmpbuf[x1++] = *buf4;/* move character */
  421.                     }
  422.                     break;
  423.  
  424.                 case 2:
  425.                     if ( *buf4 == '\n' )
  426.                     {
  427.                         state++;    /* go to final state */
  428.                     }
  429.                     else
  430.                     {
  431.                         state = 0;    /* reset the state */
  432.                     }
  433.                     tmpbuf[x1++] = *buf4;
  434.                     break;
  435.             } /* switch */
  436.             buf4++;        /* move to next byte */
  437.         }
  438.  
  439.         tmpbuf[x1] = '\0';        /* terminate it */
  440.  
  441.         if ( state < 3 )    /* we need more in the buffer */
  442.         {
  443.             if ( WriteAsync(ofp,tmpbuf,strlen(tmpbuf) ) == -1)
  444.             {
  445.                 doreq("Error writing to mailbox.",bum);
  446.                 CloseAsync(ofp);
  447.                 FreeVec(tmpbuf);
  448.                 return(0);    /* return error */
  449.             }
  450.  
  451.             /* get next buffer full */
  452.             foo = recv(s,buf,(BUFSIZE - 1),0);
  453.  
  454.             if ( foo > 0 )
  455.             {
  456.                 buf[foo] = '\0'; /* terminate it for grins */
  457.                 buf4 = buf3 = strip(buf);/* remove CRs */
  458.             }
  459.             else
  460.             { /* should never happen! */
  461.                 doreq("Internal Error.",bum);
  462.                 state = 4;/* should never happen */
  463.             }
  464.         }    /* if (state < 3) */
  465.     }    /* while (state < 3) */
  466.  
  467.     /* write out last buffer, leaving off last ".\n" */
  468.     if ( WriteAsync(ofp,tmpbuf,strlen(tmpbuf)) == -1 )
  469.     {
  470.         doreq("Error writing to Mailbox.",bum);
  471.         CloseAsync(ofp);
  472.         FreeVec(tmpbuf);
  473.         return(0);    /* return error */
  474.     }
  475.  
  476.     CloseAsync(ofp);
  477.     FreeVec(tmpbuf);
  478.     return(1);
  479.  
  480. } /* end of retrieve */
  481.  
  482. int delmessage( int s, int count )
  483. {
  484.     DoFmt(buf,"DELE %lu\r\n",count);
  485.     trans(s,buf);
  486.  
  487.     if ( valcheck(1,buf) ) return(0);
  488.  
  489.     return(1);
  490. }
  491.  
  492. int valcheck(int t, char *localtemp)
  493. {
  494.     if (t == 0)
  495.     {
  496.         doreq("Got a bogus return string.",bum);
  497.         return(1);
  498.     }
  499.  
  500.     if ( !strstr(localtemp,"+OK") )
  501.     {
  502.         doreq("Didn't get +OK",bum);
  503.  
  504.         if (localtemp[0] != '\0')
  505.         {
  506.             doreq(localtemp,bum);
  507.         }
  508.         return(1);
  509.     }
  510.     return(0);
  511. }
  512.  
  513. int trans( int s, char *mybuf )
  514. {
  515.     int foo;
  516.  
  517.     send(s,mybuf,strlen(mybuf),0);
  518.  
  519.     bzero(buf,BUFSIZE);
  520.     foo=recv(s,buf,BUFSIZE-1,0);
  521.     if ( foo < 1 )
  522.     {
  523.         return(0);
  524.     }
  525.  
  526.     buf[foo]='\0';
  527.  
  528.     return (1);
  529. }
  530.  
  531. void settitle( char *newtitle )
  532. {
  533.     if (winop)
  534.     {
  535.         SetWindowTitles(Project0Wnd,newtitle, (UBYTE *) ~0);
  536.     }
  537. }
  538.  
  539. /* Scott, this is a slight modification of your strip.  It has the exact same
  540.    functionality as yours, except it uses dynamic memory instead of the stack
  541.    for the temporary buffer.  If you want to leave your routine here,
  542.    everything should work just the same.  David */
  543.  
  544. /* function strip will strip out all the carraige returns
  545.    from the buffer and return the original pointer */
  546.  
  547. char * strip( char *mybuf )
  548. {
  549.     char tmpbuf[BUFSIZE];
  550.     ULONG x1, x2, len;
  551.  
  552.     len = strlen(mybuf);
  553.  
  554.     /* strip out the CRs */
  555.     for (x1 = x2 = 0 ; x1 < len; x1++)
  556.     {
  557.         tmpbuf[x2] = mybuf[x1];
  558.         if ( tmpbuf[x2] != '\r' ) x2++;
  559.     }
  560.  
  561.     tmpbuf[x2] = '\0';        /* terminate it */
  562.     strcpy(mybuf,tmpbuf);    /* copy back the string */
  563.  
  564.     return(mybuf);        /* return their buf ptr */
  565.  
  566. } /* end of strip */
  567.  
  568. int lastblock (char *segment)
  569. {
  570.     char *found;
  571.     int len = strlen(segment);
  572.  
  573.     if ( (found=strstr(segment,"\r\n.\r\n")))
  574.     {
  575.         /*buf[found-segment]='\n';*/
  576.         buf[found-segment]='\0'; /* used to be found-segment+2 */
  577.         return(0);
  578.     }
  579.  
  580.     if ( (len==2) && (found=strstr(segment,"\r\n")) )
  581.     {
  582.         buf[found-segment]='\0'; /* Added recently */
  583.         return(0);
  584.     }
  585.  
  586.     if ( len==1 ) /* Kludge of the century */
  587.     {
  588.         return(0);
  589.     }
  590.  
  591.     if ( (len <= 4) && (found=strstr(segment,".\r\n")) )
  592.     {
  593.         /*buf[found-segment]='\n';*/
  594.         buf[found-segment]='\0';
  595.         return(0);
  596.     }
  597.  
  598.     return(1);
  599. }
  600.  
  601. BOOL needfrom(char *mybuf,struct AsyncFile *ofp)
  602. {
  603.     if ( !strstr(mybuf,"From ") )
  604.     {
  605.         char *newtemp;
  606.  
  607.         if (newtemp=AllocVec(BIGSTRING,MEMF_CLEAR))
  608.         {
  609.             int tempsize=0;
  610.  
  611.             DoFmt(newtemp,"From %s@%s ", username,pophost);
  612.             tempsize=strlen(newtemp);
  613.             DoFmt((newtemp+tempsize),"%s\n",datestr((newtemp+tempsize)));
  614.             WriteAsync(ofp,newtemp,strlen(newtemp));
  615.             FreeVec(newtemp);
  616.         }
  617.  
  618.         return(TRUE);
  619.     }
  620.     return(FALSE);
  621. }
  622.